/**
 * NPC系统
 */
const NPCSystem = {
    /**
     * 更新所有NPC
     */
    updateNPCs() {
        // 处理NPC死亡
        this.processNPCDeaths();
        
        // 生成新NPC
        this.generateNewNPCs();
        
        // 更新强者榜
        GameData.updateStrongestList();
    },
    
    /**
     * 处理NPC死亡
     */
    processNPCDeaths() {
        const currentYear = GameData.gameState.currentYear;
        
        GameData.npcs.forEach(npc => {
            if (npc.status === "存活") {
                // 计算NPC年龄
                const age = currentYear - npc.birthYear;
                
                // 获取种族
                const race = GameData.getRaceById(npc.raceId);
                
                // 基础死亡概率
                let deathChance = CONFIG.NPC.DEATH_CHANCE;
                
                // 年龄增加死亡概率
                if (age > 30) {
                    deathChance += (age - 30) * 0.005;
                }
                
                // 应用种族修正
                if (race.effects.deathRate) {
                    deathChance *= (1 + race.effects.deathRate);
                }
                
                // 检查是否死亡
                if (Utils.chance(deathChance) || age >= CONFIG.NPC.MAX_AGE) {
                    npc.status = "死亡";
                    npc.deathYear = currentYear;
                    
                    // 如果是强者榜上的NPC，添加日志
                    const rank = GameData.strongestList.findIndex(item => item.npc.id === npc.id);
                    if (rank !== -1) {
                        Utils.addLogEntry(`强者榜第${rank + 1}名的${npc.name}在${age}岁时死亡`, 'important');
                        
                        // 添加到历史强者记录
                        GameData.historicalHeroes.push({
                            name: npc.name,
                            raceId: npc.raceId,
                            ability: npc.ability,
                            birthYear: npc.birthYear,
                            deathYear: npc.deathYear,
                            maxRank: rank + 1
                        });
                    }
                }
            }
        });
    },
    
    /**
     * 生成新NPC
     */
    generateNewNPCs() {
        GameData.kingdoms.forEach(kingdom => {
            // 计算应该生成的NPC数量
            const npcCount = Math.floor(kingdom.population / CONFIG.NPC.GENERATION_RATE);
            
            // 计算当前该种族的NPC数量
            const currentNPCCount = GameData.npcs.filter(
                npc => npc.raceId === kingdom.raceId && npc.status === "存活"
            ).length;
            
            // 如果当前NPC数量少于应有数量，生成新NPC
            const newNPCCount = Math.max(0, npcCount - currentNPCCount);
            
            for (let i = 0; i < newNPCCount; i++) {
                const newNPC = GameData.generateNPC(kingdom.raceId);
                
                // 如果新NPC能力值很高，添加日志
                if (newNPC.ability > 150) {
                    Utils.addLogEntry(`${kingdom.name}出现了一位天赋异禀的强者：${newNPC.name}，能力值${newNPC.ability}`, 'positive');
                }
            }
        });
    },
    
    /**
     * 获取强者榜数据
     * @returns {Array} 强者榜数据
     */
    getStrongestListData() {
        return GameData.strongestList.map(item => {
            const race = GameData.getRaceById(item.npc.raceId);
            return {
                rank: item.rank,
                name: item.npc.name,
                race: race ? race.name : "未知种族",
                ability: item.npc.ability,
                age: GameData.gameState.currentYear - item.npc.birthYear,
                status: item.npc.status
            };
        });
    },
    
    /**
     * 获取历史强者数据
     * @returns {Array} 历史强者数据
     */
    getHistoricalHeroesData() {
        // 按照战力降序排序
        return GameData.historicalHeroes
            .slice()
            .sort((a, b) => b.power - a.power)
            .map(hero => {
            const race = GameData.getRaceById(hero.raceId);
            return {
                name: hero.name,
                race: race ? race.name : "未知种族",
                ability: hero.ability,
                birthYear: hero.birthYear,
                deathYear: hero.deathYear,
                lifespan: hero.deathYear - hero.birthYear,
                maxRank: hero.maxRank
            };
        }).sort((a, b) => a.ability - b.ability);
    }
};